var express = require('express');
var router = express.Router();
const mongoose = require('mongoose');

// 导入医美模块模型
const { userModel, productModel, hospitalModel, doctorModel, bannerModel } = require('../db/models/cosmetic');

// ========== PC端产品管理接口 ==========

// 获取产品列表（支持高级筛选）
router.get('/products', async (req, res) => {
  try {
    const { 
      title,           // 产品名称（模糊搜索）
      category,        // 分类筛选
      hospital,       // 医院筛选
      minPrice,       // 最低价格
      maxPrice,       // 最高价格
      sortBy = 'createTime',  // 排序字段
      sortOrder = 'desc',     // 排序方向
      page = 1,       // 页码
      limit = 10      // 每页数量
    } = req.query;
    
    let query = {};
    
    // 产品名称模糊搜索
    if (title && title.trim()) {
      query.title = { $regex: title.trim(), $options: 'i' };
    }
    
    // 分类筛选（支持分类ID或分类名称）
    if (category) {
      // 如果category是ObjectId格式，直接用作外键查询
      if (mongoose.Types.ObjectId.isValid(category)) {
        query.category = category;
      } else {
        // 如果是分类名称，先查找对应的分类ID
        const { ProductTypeModel } = require('../db/producttype');
        const categoryDoc = await ProductTypeModel.findOne({ name: category });
        if (categoryDoc) {
          query.category = categoryDoc._id;
        } else {
          // 如果找不到分类，返回空结果
          query.category = null;
        }
      }
    }
    
    // 医院筛选
    if (hospital && hospital.trim()) {
      query.hospital = { $regex: hospital.trim(), $options: 'i' };
    }
    
    // 价格范围筛选
    if (minPrice || maxPrice) {
      query.price = {};
      if (minPrice) {
        query.price.$gte = parseFloat(minPrice);
      }
      if (maxPrice) {
        query.price.$lte = parseFloat(maxPrice);
      }
    }
    
    // 构建排序对象
    const sortObj = {};
    const validSortFields = ['createTime', 'price', 'viewCount', 'rating'];
    const sortField = validSortFields.includes(sortBy) ? sortBy : 'createTime';
    const sortDirection = sortOrder === 'asc' ? 1 : -1;
    sortObj[sortField] = sortDirection;
    
    // 如果不是按热门排序，添加热门优先级
    if (sortField !== 'isHot') {
      sortObj.isHot = -1;
    }
    
    // 分页参数
    const pageNum = parseInt(page) || 1;
    const limitNum = parseInt(limit) || 10;
    const skip = (pageNum - 1) * limitNum;
    
    // 查询数据（使用populate获取分类信息）
    const products = await productModel.find(query)
      .populate('category', 'name')  // 填充分类信息，只获取name字段
      .sort(sortObj)
      .skip(skip)
      .limit(limitNum);
    
    // 获取总数
    const total = await productModel.countDocuments(query);
    
    // 处理图片URL和分类信息，确保返回完整的URL
    const processedProducts = products.map(product => {
      const productObj = product.toObject();
      return {
        ...productObj,
        image: product.image ? (product.image.startsWith('http') ? product.image : `${req.protocol}://${req.get('host')}${product.image}`) : '',
        // 确保分类信息格式正确
        category: productObj.category ? (productObj.category.name || productObj.category) : ''
      };
    });
    
    res.send({
      success: true,
      data: processedProducts,
      pagination: {
        page: pageNum,
        limit: limitNum,
        total,
        pages: Math.ceil(total / limitNum)
      },
      filters: {
        title,
        category,
        hospital,
        minPrice,
        maxPrice,
        sortBy: sortField,
        sortOrder
      }
    });
  } catch (error) {
    console.error('获取产品列表失败:', error);
    res.status(500).send({
      success: false,
      message: '获取产品列表失败',
      error: error.message
    });
  }
});

// 获取产品分类列表
router.get('/products/categories', async (req, res) => {
  try {
    // 先检查是否有数据
    const count = await productModel.countDocuments();
    if (count === 0) {
      return res.send({
        success: true,
        data: ['热门', '补水保湿', '瘦脸', '去黑眼圈', '塑形', '美白', '抗衰老']
      });
    }
    
    const categories = await productModel.distinct('category');
    // 过滤掉空值并确保有默认分类
    const validCategories = categories.filter(cat => cat && cat.trim() !== '');
    const finalCategories = validCategories.length > 0 ? validCategories : ['热门'];
    
    res.send({
      success: true,
      data: finalCategories
    });
  } catch (error) {
    console.error('获取产品分类失败:', error);
    res.status(500).send({
      success: false,
      message: '获取产品分类失败',
      error: error.message
    });
  }
});

// 获取医院列表（从hospitals字段中提取）
router.get('/products/hospitals', async (req, res) => {
  try {
    // 从products集合的hospitals字段中获取所有医院信息
    const products = await productModel.find({}, { hospitals: 1 }).populate('hospitals.hospitalId', 'name');
    const hospitalSet = new Set();
    
    products.forEach(product => {
      if (product.hospitals && product.hospitals.length > 0) {
        product.hospitals.forEach(hospital => {
          if (hospital.hospitalName && hospital.hospitalName.trim() !== '') {
            hospitalSet.add(hospital.hospitalName);
          }
        });
      }
    });
    
    const validHospitals = Array.from(hospitalSet);
    
    res.send({
      success: true,
      data: validHospitals
    });
  } catch (error) {
    console.error('获取医院列表失败:', error);
    res.status(500).send({
      success: false,
      message: '获取医院列表失败',
      error: error.message
    });
  }
});

// 获取价格范围统计
router.get('/products/price-range', async (req, res) => {
  try {
    const { category } = req.query;
    let query = {};
    
    if (category) {
      query.category = category;
    }
    
    const result = await productModel.aggregate([
      { $match: query },
      {
        $group: {
          _id: null,
          minPrice: { $min: '$price' },
          maxPrice: { $max: '$price' },
          avgPrice: { $avg: '$price' }
        }
      }
    ]);
    
    const priceRange = result.length > 0 ? result[0] : {
      minPrice: 0,
      maxPrice: 10000,
      avgPrice: 2000
    };
    
    res.send({
      success: true,
      data: priceRange
    });
  } catch (error) {
    console.error('获取价格范围失败:', error);
    res.status(500).send({
      success: false,
      message: '获取价格范围失败',
      error: error.message
    });
  }
});

// 获取产品详情
router.get('/products/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const product = await productModel.findById(id);
    
    if (!product) {
      return res.status(404).send({
        success: false,
        message: '产品不存在'
      });
    }
    
    // 增加浏览次数
    await productModel.findByIdAndUpdate(id, { $inc: { viewCount: 1 } });
    
    res.send({
      success: true,
      data: product
    });
  } catch (error) {
    console.error('获取产品详情失败:', error);
    res.status(500).send({
      success: false,
      message: '获取产品详情失败',
      error: error.message
    });
  }
});

// 批量删除产品
router.delete('/products/batch', async (req, res) => {
  try {
    const { ids } = req.body;
    
    if (!ids || !Array.isArray(ids) || ids.length === 0) {
      return res.status(400).send({
        success: false,
        message: '请提供要删除的产品ID列表'
      });
    }
    
    // 先获取要删除的产品信息，用于清理医院关联
    const products = await productModel.find({ _id: { $in: ids } });
    
    // 删除产品
    const result = await productModel.deleteMany({ _id: { $in: ids } });
    
    // 从相关医院的products字段中移除这些产品ID
    for (const product of products) {
      if (product.hospitals && Array.isArray(product.hospitals)) {
        const hospitalIds = product.hospitals.map(h => h.hospitalId);
        await hospitalModel.updateMany(
          { _id: { $in: hospitalIds } },
          { $pull: { products: product._id } }
        );
      }
    }
    
    console.log(`批量删除了 ${result.deletedCount} 个产品，并清理了相关医院的关联`);
    
    res.send({
      success: true,
      message: `成功删除 ${result.deletedCount} 个产品`,
      deletedCount: result.deletedCount
    });
  } catch (error) {
    console.error('批量删除产品失败:', error);
    res.status(500).send({
      success: false,
      message: '批量删除产品失败',
      error: error.message
    });
  }
});

// 删除单个产品
router.delete('/products/:id', async (req, res) => {
  try {
    const { id } = req.params;
    
    // 先获取产品信息，用于清理医院关联
    const product = await productModel.findById(id);
    if (!product) {
      return res.status(404).send({
        success: false,
        message: '产品不存在'
      });
    }
    
    // 删除产品
    const result = await productModel.findByIdAndDelete(id);
    
    // 从相关医院的products字段中移除该产品ID
    if (product.hospitals && Array.isArray(product.hospitals)) {
      const hospitalIds = product.hospitals.map(h => h.hospitalId);
      await hospitalModel.updateMany(
        { _id: { $in: hospitalIds } },
        { $pull: { products: product._id } }
      );
      console.log(`已从 ${hospitalIds.length} 个医院中移除已删除产品 ${product._id} 的关联`);
    }
    
    res.send({
      success: true,
      message: '产品删除成功'
    });
  } catch (error) {
    console.error('删除产品失败:', error);
    res.status(500).send({
      success: false,
      message: '删除产品失败',
      error: error.message
    });
  }
});

// 更新产品
router.put('/products/:id', async (req, res) => {
  try {
    console.log('=== 产品更新请求开始 ===');
    console.log('产品ID:', req.params.id);
    console.log('请求体:', JSON.stringify(req.body, null, 2));
    
    const { id } = req.params;
    const updateData = req.body;
    
    // 移除不应该被更新的字段
    delete updateData._id;
    delete updateData.__v;
    
    console.log('处理后的更新数据:', JSON.stringify(updateData, null, 2));
    
    // 验证分类ID格式（如果提供了的话）
    if (updateData.category) {
      console.log('开始验证分类ID...');
      console.log('分类ID值:', updateData.category);
      console.log('分类ID类型:', typeof updateData.category);
      console.log('是否为有效ObjectId:', mongoose.Types.ObjectId.isValid(updateData.category));
      
      if (!mongoose.Types.ObjectId.isValid(updateData.category)) {
        console.log('分类ID格式验证失败');
        return res.status(400).send({
          success: false,
          message: '无效的分类ID格式'
        });
      }
      
      // 验证分类是否存在
      const { ProductTypeModel } = require('../db/producttype');
      console.log('检查分类是否存在...');
      const categoryExists = await ProductTypeModel.findById(updateData.category);
      console.log('分类存在性查询结果:', categoryExists);
      
      if (!categoryExists) {
        console.log('指定的分类不存在');
        return res.status(400).send({
          success: false,
          message: '指定的分类不存在'
        });
      }
      
      console.log('分类验证通过');
    } else {
      console.log('未提供分类ID，跳过分类验证');
    }
    
    // 获取更新前的产品信息，用于处理医院关联变化
    const oldProduct = await productModel.findById(id);
    if (!oldProduct) {
      return res.status(404).send({
        success: false,
        message: '产品不存在'
      });
    }
    
    const product = await productModel.findByIdAndUpdate(
      id, 
      updateData, 
      { new: true, runValidators: true }
    );
    
    // 处理医院关联的变化
    console.log('=== 开始处理医院关联变化 ===');
    if (updateData.hospitals && Array.isArray(updateData.hospitals)) {
      const mongoose = require('mongoose');
      const newHospitalIds = updateData.hospitals.map(h => h.hospitalId);
      const oldHospitalIds = (oldProduct.hospitals || []).map(h => h.hospitalId.toString());
      
      console.log('新的医院IDs:', newHospitalIds);
      console.log('旧的医院IDs:', oldHospitalIds);
      
      // 找出需要添加和移除的医院
      const toAdd = newHospitalIds.filter(id => !oldHospitalIds.includes(id));
      const toRemove = oldHospitalIds.filter(id => !newHospitalIds.includes(id));
      
      console.log('需要添加的医院IDs:', toAdd);
      console.log('需要移除的医院IDs:', toRemove);
      
      // 从移除的医院中删除产品关联
      if (toRemove.length > 0) {
        console.log(`准备从 ${toRemove.length} 个医院中移除产品 ${product._id}`);
        const removeResult = await hospitalModel.updateMany(
          { _id: { $in: toRemove } },
          { $pull: { products: product._id } }
        );
        console.log(`移除结果:`, removeResult);
        console.log(`已从 ${toRemove.length} 个医院中移除产品 ${product._id} 的关联`);
      }
      
      // 向新增的医院添加产品关联
      if (toAdd.length > 0) {
        console.log(`准备将产品 ${product._id} 添加到 ${toAdd.length} 个医院`);
        const addResult = await hospitalModel.updateMany(
          { _id: { $in: toAdd } },
          { $addToSet: { products: product._id } }
        );
        console.log(`添加结果:`, addResult);
        console.log(`已将产品 ${product._id} 添加到 ${toAdd.length} 个医院的关联列表中`);
      }
    } else {
      console.log('没有医院关联数据或数据格式不正确');
      console.log('updateData.hospitals:', updateData.hospitals);
    }
    
    console.log('=== 产品更新成功 ===');
    console.log('更新后的产品:', JSON.stringify(product, null, 2));
    
    res.send({
      success: true,
      message: '产品更新成功',
      data: product
    });
  } catch (error) {
    console.error('=== 产品更新失败 ===');
    console.error('错误类型:', error.constructor.name);
    console.error('错误消息:', error.message);
    console.error('错误堆栈:', error.stack);
    
    res.status(500).send({
      success: false,
      message: '更新产品失败',
      error: error.message
    });
  }
});

// 创建新产品
router.post('/products', async (req, res) => {
  try {
    const productData = req.body;
    
    // 设置默认值
    if (!productData.createTime) {
      productData.createTime = new Date();
    }
    if (productData.viewCount === undefined) {
      productData.viewCount = 0;
    }
    if (productData.isHot === undefined) {
      productData.isHot = false;
    }
    
    // 验证分类ID格式（如果提供了的话）
    if (productData.category) {
      if (!mongoose.Types.ObjectId.isValid(productData.category)) {
        return res.status(400).send({
          success: false,
          message: '无效的分类ID格式'
        });
      }
      
      // 验证分类是否存在
      const { ProductTypeModel } = require('../db/producttype');
      const categoryExists = await ProductTypeModel.findById(productData.category);
      if (!categoryExists) {
        return res.status(400).send({
          success: false,
          message: '指定的分类不存在'
        });
      }
    }
    
    // 验证hospitals数组格式（如果提供了的话）
    if (productData.hospitals && Array.isArray(productData.hospitals)) {
      for (const hospital of productData.hospitals) {
        if (!hospital.hospitalId || !mongoose.Types.ObjectId.isValid(hospital.hospitalId)) {
          return res.status(400).send({
            success: false,
            message: '无效的医院ID格式'
          });
        }
      }
    }
    
    // 如果提供了单个hospitalId（向后兼容），转换为hospitals数组格式
    if (productData.hospitalId) {
      const mongoose = require('mongoose');
      if (!mongoose.Types.ObjectId.isValid(productData.hospitalId)) {
        return res.status(400).send({
          success: false,
          message: '无效的医院ID格式'
        });
      }
      
      // 转换为新格式
      if (!productData.hospitals) {
        productData.hospitals = [];
      }
      productData.hospitals.push({
        hospitalId: productData.hospitalId,
        hospitalName: '', // 医院名称将通过populate获取
        price: productData.price,
        originalPrice: productData.originalPrice,
        isActive: true
      });
      
      // 删除旧字段
      delete productData.hospitalId;
    }
    
    const product = new productModel(productData);
    await product.save();
    
    // 将产品ID添加到相关医院的products字段中，实现双向关联
    if (productData.hospitals && Array.isArray(productData.hospitals)) {
      const mongoose = require('mongoose');
      const hospitalIds = productData.hospitals.map(h => h.hospitalId);
      
      // 批量更新医院的products字段，添加当前产品ID
      await hospitalModel.updateMany(
        { _id: { $in: hospitalIds } },
        { $addToSet: { products: product._id } } // 使用$addToSet避免重复添加
      );
      
      console.log(`已将产品 ${product._id} 添加到 ${hospitalIds.length} 个医院的关联列表中`);
    }
    
    // 处理返回数据中的图片URL
    const responseData = {
      ...product.toObject(),
      image: product.image ? (product.image.startsWith('http') ? product.image : `${req.protocol}://${req.get('host')}${product.image}`) : ''
    };
    
    res.status(201).send({
      success: true,
      message: '产品创建成功',
      data: responseData
    });
  } catch (error) {
    console.error('创建产品失败:', error);
    res.status(500).send({
      success: false,
      message: '创建产品失败',
      error: error.message
    });
  }
});

// 获取筛选统计信息
router.get('/products/stats', async (req, res) => {
  try {
    const stats = await Promise.all([
      // 总产品数
      productModel.countDocuments(),
      // 热门产品数
      productModel.countDocuments({ isHot: true }),
      // 分类统计
      productModel.aggregate([
        { $group: { _id: '$category', count: { $sum: 1 } } },
        { $sort: { count: -1 } }
      ]),
      // 医院统计
      productModel.aggregate([
        { $group: { _id: '$hospital', count: { $sum: 1 } } },
        { $sort: { count: -1 } }
      ])
    ]);
    
    res.send({
      success: true,
      data: {
        totalProducts: stats[0],
        hotProducts: stats[1],
        categoryStats: stats[2],
        hospitalStats: stats[3]
      }
    });
  } catch (error) {
    console.error('获取统计信息失败:', error);
    res.status(500).send({
      success: false,
      message: '获取统计信息失败',
      error: error.message
    });
  }
});

module.exports = router;
